package com.cardcaptorsakura.repository;

import com.cardcaptorsakura.model.entity.Memory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.data.mongodb.repository.Aggregation;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

/**
 * 记忆存储仓库接口
 * 提供记忆数据的CRUD操作和复杂查询功能
 */
@Repository
public interface MemoryRepository extends MongoRepository<Memory, String> {

    /**
     * 根据用户ID查找记忆
     */
    List<Memory> findByUserIdAndDeletedFalse(String userId);

    /**
     * 根据用户ID分页查找记忆
     */
    Page<Memory> findByUserIdAndDeletedFalse(String userId, Pageable pageable);

    /**
     * 根据用户ID和记忆类型查找记忆
     */
    List<Memory> findByUserIdAndMemoryTypeAndDeletedFalse(String userId, Memory.MemoryType memoryType);

    /**
     * 根据用户ID和记忆类型分页查找记忆
     */
    Page<Memory> findByUserIdAndMemoryTypeAndDeletedFalse(String userId, Memory.MemoryType memoryType, Pageable pageable);

    /**
     * 根据人格ID查找记忆
     */
    List<Memory> findByPersonaIdAndDeletedFalse(String personaId);

    /**
     * 根据人格ID分页查找记忆
     */
    Page<Memory> findByPersonaIdAndDeletedFalse(String personaId, Pageable pageable);

    /**
     * 根据会话ID查找记忆
     */
    List<Memory> findByConversationIdAndDeletedFalseOrderByCreatedAtAsc(String conversationId);

    /**
     * 根据用户ID和会话ID查找记忆
     */
    List<Memory> findByUserIdAndConversationIdAndDeletedFalseOrderByCreatedAtAsc(String userId, String conversationId);

    /**
     * 根据记忆链ID查找记忆
     */
    List<Memory> findByMemoryChainIdAndDeletedFalseOrderByCreatedAtAsc(String memoryChainId);

    /**
     * 根据父记忆ID查找子记忆
     */
    List<Memory> findByParentMemoryIdAndDeletedFalse(String parentMemoryId);

    /**
     * 根据用户ID和重要性评分范围查找记忆
     */
    @Query("{'userId': ?0, 'importance': {$gte: ?1, $lte: ?2}, 'deleted': false}")
    List<Memory> findByUserIdAndImportanceRange(String userId, int minImportance, int maxImportance);

    /**
     * 根据用户ID和重要性评分范围分页查找记忆
     */
    @Query("{'userId': ?0, 'importance': {$gte: ?1, $lte: ?2}, 'deleted': false}")
    Page<Memory> findByUserIdAndImportanceRange(String userId, int minImportance, int maxImportance, Pageable pageable);

    /**
     * 根据用户ID和时间范围查找记忆
     */
    @Query("{'userId': ?0, 'createdAt': {$gte: ?1, $lte: ?2}, 'deleted': false}")
    List<Memory> findByUserIdAndCreatedAtBetween(String userId, LocalDateTime startTime, LocalDateTime endTime);

    /**
     * 根据用户ID和时间范围分页查找记忆
     */
    @Query("{'userId': ?0, 'createdAt': {$gte: ?1, $lte: ?2}, 'deleted': false}")
    Page<Memory> findByUserIdAndCreatedAtBetween(String userId, LocalDateTime startTime, LocalDateTime endTime, Pageable pageable);

    /**
     * 根据用户ID和最后访问时间查找活跃记忆
     */
    @Query("{'userId': ?0, 'lastAccessedAt': {$gte: ?1}, 'deleted': false}")
    List<Memory> findActiveMemoriesByUserId(String userId, LocalDateTime since);

    /**
     * 根据用户ID查找高重要性记忆
     */
    @Query("{'userId': ?0, 'importance': {$gte: ?1}, 'deleted': false}")
    List<Memory> findHighImportanceMemoriesByUserId(String userId, int minImportance);

    /**
     * 根据用户ID查找最近的记忆
     */
    List<Memory> findTop10ByUserIdAndDeletedFalseOrderByCreatedAtDesc(String userId);

    /**
     * 根据用户ID查找最常访问的记忆
     */
    List<Memory> findTop10ByUserIdAndDeletedFalseOrderByAccessCountDesc(String userId);

    /**
     * 根据用户ID和情感标签查找记忆
     */
    @Query("{'userId': ?0, 'emotionTags': {$in: ?1}, 'deleted': false}")
    List<Memory> findByUserIdAndEmotionTags(String userId, List<String> emotionTags);

    /**
     * 根据用户ID和主题标签查找记忆
     */
    @Query("{'userId': ?0, 'topicTags': {$in: ?1}, 'deleted': false}")
    List<Memory> findByUserIdAndTopicTags(String userId, List<String> topicTags);

    /**
     * 根据用户ID和关键词查找记忆
     */
    @Query("{'userId': ?0, 'keywords': {$in: ?1}, 'deleted': false}")
    List<Memory> findByUserIdAndKeywords(String userId, List<String> keywords);

    /**
     * 全文搜索记忆
     */
    @Query("{'userId': ?0, '$text': {'$search': ?1}, 'deleted': false}")
    List<Memory> searchMemoriesByText(String userId, String searchText);

    /**
     * 全文搜索记忆（分页）
     */
    @Query("{'userId': ?0, '$text': {'$search': ?1}, 'deleted': false}")
    Page<Memory> searchMemoriesByText(String userId, String searchText, Pageable pageable);

    /**
     * 根据用户ID和内容模糊查找记忆
     */
    @Query("{'userId': ?0, '$or': [{'title': {$regex: ?1, $options: 'i'}}, {'content': {$regex: ?1, $options: 'i'}}], 'deleted': false}")
    List<Memory> findByUserIdAndContentContaining(String userId, String content);

    /**
     * 根据用户ID和内容模糊查找记忆（分页）
     */
    @Query("{'userId': ?0, '$or': [{'title': {$regex: ?1, $options: 'i'}}, {'content': {$regex: ?1, $options: 'i'}}], 'deleted': false}")
    Page<Memory> findByUserIdAndContentContaining(String userId, String content, Pageable pageable);

    /**
     * 查找过期的记忆
     */
    @Query("{'expiresAt': {$lte: ?0}, 'deleted': false}")
    List<Memory> findExpiredMemories(LocalDateTime now);

    /**
     * 查找长时间未访问的记忆
     */
    @Query("{'lastAccessedAt': {$lte: ?0}, 'deleted': false}")
    List<Memory> findInactiveMemories(LocalDateTime threshold);

    /**
     * 查找低重要性且长时间未访问的记忆
     */
    @Query("{'importance': {$lte: ?0}, 'lastAccessedAt': {$lte: ?1}, 'deleted': false}")
    List<Memory> findLowImportanceInactiveMemories(int maxImportance, LocalDateTime threshold);

    /**
     * 根据用户ID统计记忆数量
     */
    long countByUserIdAndDeletedFalse(String userId);

    /**
     * 根据用户ID和记忆类型统计记忆数量
     */
    long countByUserIdAndMemoryTypeAndDeletedFalse(String userId, Memory.MemoryType memoryType);

    /**
     * 根据用户ID统计总访问次数
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $group: { '_id': null, 'totalAccess': { $sum: '$accessCount' } } }"
    })
    Optional<Integer> getTotalAccessCountByUserId(String userId);

    /**
     * 根据用户ID获取平均重要性评分
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $group: { '_id': null, 'avgImportance': { $avg: '$importance' } } }"
    })
    Optional<Double> getAverageImportanceByUserId(String userId);

    /**
     * 根据用户ID获取记忆类型分布
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $group: { '_id': '$memoryType', 'count': { $sum: 1 } } }",
        "{ $sort: { 'count': -1 } }"
    })
    List<MemoryTypeCount> getMemoryTypeDistributionByUserId(String userId);

    /**
     * 根据用户ID获取最常用的情感标签
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $unwind: '$emotionTags' }",
        "{ $group: { '_id': '$emotionTags', 'count': { $sum: 1 } } }",
        "{ $sort: { 'count': -1 } }",
        "{ $limit: 10 }"
    })
    List<TagCount> getTopEmotionTagsByUserId(String userId);

    /**
     * 根据用户ID获取最常用的主题标签
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $unwind: '$topicTags' }",
        "{ $group: { '_id': '$topicTags', 'count': { $sum: 1 } } }",
        "{ $sort: { 'count': -1 } }",
        "{ $limit: 10 }"
    })
    List<TagCount> getTopTopicTagsByUserId(String userId);

    /**
     * 根据用户ID获取最常用的关键词
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $unwind: '$keywords' }",
        "{ $group: { '_id': '$keywords', 'count': { $sum: 1 } } }",
        "{ $sort: { 'count': -1 } }",
        "{ $limit: 10 }"
    })
    List<TagCount> getTopKeywordsByUserId(String userId);

    /**
     * 根据用户ID获取记忆创建时间分布（按小时）
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $group: { '_id': { $hour: '$createdAt' }, 'count': { $sum: 1 } } }",
        "{ $sort: { '_id': 1 } }"
    })
    List<HourlyCount> getMemoryCreationHourlyDistributionByUserId(String userId);

    /**
     * 根据用户ID获取记忆创建时间分布（按天）
     */
    @Aggregation(pipeline = {
        "{ $match: { 'userId': ?0, 'deleted': false } }",
        "{ $group: { '_id': { $dayOfWeek: '$createdAt' }, 'count': { $sum: 1 } } }",
        "{ $sort: { '_id': 1 } }"
    })
    List<DailyCount> getMemoryCreationDailyDistributionByUserId(String userId);

    /**
     * 根据相关记忆ID查找记忆
     */
    @Query("{'relatedMemoryIds': {$in: [?0]}, 'deleted': false}")
    List<Memory> findByRelatedMemoryId(String memoryId);

    /**
     * 批量更新记忆的重要性评分
     */
    @Query("{'_id': {$in: ?0}}")
    List<Memory> findByIdIn(List<String> ids);

    /**
     * 软删除记忆
     */
    @Query(value = "{'_id': ?0}", delete = false)
    Optional<Memory> findByIdAndDeletedFalse(String id);

    /**
     * 根据用户ID软删除所有记忆
     */
    @Query("{'userId': ?0, 'deleted': false}")
    List<Memory> findAllByUserIdForDeletion(String userId);

    /**
     * 查找需要清理的已删除记忆
     */
    @Query("{'deleted': true, 'deletedAt': {$lte: ?0}}")
    List<Memory> findDeletedMemoriesForCleanup(LocalDateTime threshold);

    /**
     * 记忆类型统计结果
     */
    interface MemoryTypeCount {
        Memory.MemoryType getId();
        long getCount();
    }

    /**
     * 标签统计结果
     */
    interface TagCount {
        String getId();
        long getCount();
    }

    /**
     * 小时统计结果
     */
    interface HourlyCount {
        int getId();
        long getCount();
    }

    /**
     * 日统计结果
     */
    interface DailyCount {
        int getId();
        long getCount();
    }
}